版本

建议安装 Microsoft R Open,对 R 中向量和矩阵的向量化操作进行了大幅优化,无需引入任何包,就能自动调用多核进行并行计算,可提高运算速度数十倍。

这也意味着,向量化运算是 R 最基本、最主要的代码风格。

但是,Microsoft R Open 的某些包更新不够及时(如 rmarkdown)。为了 Knit 的方便,可以 Rstudio 选择 R 的最新版,在 VSCode 中用 Microsoft R Open 日常加速计算。

System interaction

Environment

R 中词法作用域的机理通过环境实现。

函数优先在内部环境搜索用到的变量,搜索不到时,就到上一级环境搜索。

每加载一个扩展包,这个包的环境都会插入搜索路径,并位于全局环境之前。

环境交互函数
ls()/objects() 列出当前工作空间的所有对象
ls.str(mode=, pattern=) 显示当前环境的结构。mode 参数过滤对象类型,pattern 参数为正则表达式,过滤对象名
rm() 删除一个或更多个对象。
rm(list=ls(all=TRUE)) 删除所有对象
getOption() 查看全局选项
options() 设定全局选项。如 digits=7, 设定显示数字的位数。warn=0, 可以改为1,在警告产生时立即显示。

Path

Working Directory
dir.create() 创建一个目录
getwd()/setwd() 查看/设定当前工作目录

由此扩展,R 也可以完成文件管理工作。

Memory

tracemem()查看对象的内存地址

Time

Sys.sleep() 使程序暂停若干秒,一般用于某些循环(爬虫、动画等),故意降低运行频率

sys.time() 读取系统时间;

system.time() 参数为大括号括起来的代码段,计算代码段运行时间

t1 <- Sys.time()
...
t2 <- Sys.time()
print(t2 - t1) # 中间代码的运行时间

system.time({
  ...
}) # 代码段运行时间
A <- matrix(1:1000000, 1000)

system.time({
  A %*% A
})
#> 用户 系统 流逝 
#> 1.16 0.00 1.16

Help

Help
help(functionName)?functionName 查看一个函数的用法
example(functionName) 运行帮主文件中的例子
help.search(keyword)??keyword 在==所有包==的文档中搜索关键词
help(package = "") 查看一个包的帮助
help(options) 显示可用选项的说明
options() 显示或设置当前选项

History

History
history(#) 显示最近使用过的#个命令(默认值为25)
savehistory("myfile") 保存命令历史到文件myfile中(默认值为.Rhistory)
loadhistory("myfile") 载入一个命令历史文件(默认值为.Rhistory)

Modularization

R Package

Package
install.packages("package") 安装包
installed.packages() 返回一个字符串矩阵,内含所有已安装的包的多项信息
library() 无参数时,显示库中已经安装了哪些包
library(package) 有参数时,载入包
unloadNamespace(package) 解除载入一个包
search() 查看环境中已经加载了哪些包
getOption('defaultPackages') 查看默认加载的 R 包
update.packages("package") 升级包。若不填入参数,则自动升级所有可以升级的包
package::function() 调用相应包的函数(有时多个包用同一个名字命名不同的函数,会发生冲突,只能这样引用
data() 查看所有预先提供的数据
data(package="") 查看某个包所有预先提供的数据
data(dataset_name, package=) 读入包中数据
installed.packages() %>% View()

新装 R 时安装常用包

# 重装 R 前把已安装包的名称(第一列)存为一个 .rds 文件
saveRDS(installed.packages()[, 1], "./download-packages.rds")
# 重装 R 后读取该文件,并安装这些 packages
install.packages(readRDS("./download-packages.rds"))

查看包的流行程度

# 查看 R 包的下载次数
library(cranlogs)

fashion <- function(package_name) {
  d <- cran_downloads(
    package = package_name,
    from = "2022-01-01",
    to = "2022-03-31"
  )
  sum(d$count)
}

fashion("ggplot2")
#> [1] 6591799
fashion("tidyverse")
#> [1] 2414103
fashion("data.table")
#> [1] 2512297
fashion("plotly")
#> [1] 916778

R Script

语法

source('xxx.R')

最佳实践

由于 R 的懒加载特性,模块中的代码不会运行,故 .R 脚本文件作为模块时,不必加载配置常量和包,纯写函数即可,所有的包和配置由主文件加载。

二进制数据文件

数据处理的中间结果一般保存为 .rda 或 .rds 即可;有其他用途的数据转换结果,才有必要保存为 .csv 或 .json

二者区别:

  1. saveRDS/readRDS 仅处理单个 R 对象。但是,它们比多对象存储方法更灵活,因为还原对象的对象名称不必与存储对象时的对象名称相同
  2. .rda 不对数据进行压缩,读写速度较快;.rds 会先对文件进行压缩再保存,速度相对稍慢。

Code Style

格式化

styler 包

styler - A non-invasive source code formatter for R (lorenzwalthert.github.io)

install.packages("styler")
  • style_text() styles a string
  • style_file() styles R and Rmd files
  • style_dir() styles all R and/or Rmd files in a directory.
  • 最常用
    • RStudio Addins 菜单,styles the active file R or Rmd file, or the highlighted code.
    • 或在 console 中输入styler:::style_active_file()

Google R Style

一般性规则

  • 尽量避免使用attach(), detach()
  • Error 应该使用Stop()来抛出
  • S3 类和 S4 类的函数不要一起使用

命名

对象命名以句号.分隔,不用下划线

函数名首字母大写,驼峰式命名法,不用句号分隔

注释

注释行以#开头,后加一个空格

代码行内短注释需要在代码后面空两格,然后#,再加一个空格

对变量和函数的说明写在它们的上方(紧邻),VSCode 的 R 插件能够自动识别

总体布局与顺序

  1. 版权声明
  2. 作者信息
  3. 文件说明, 包括程序的目的,输入以及输出
  4. source() 和 library() 说明
  5. 函数定义
  6. 可执行语句, 如果有的话 (例如, print, plot)

单元测试应在另一个独立的的文件中进行

R 程序效率

Vectorization

向量化运算,即对应元素执行同样的运算,适用于向量和矩阵。

如果运算符两边的变量 size 不相同,size 较小的变量会自动循环扩展,与 size 较大的变量保持一致。返回值的 size 将和较大的变量保持一致。

在计算矩阵的哈达马积、或对向量/矩阵的所有元素执行同样的变换时,向量化运算非常方便。

R 中的运算符和函数默认支持向量化运算,这是 R 的一大特色,Microsoft R Open 还对向量和矩阵的向量化运算进行了并行优化。因此,用好向量化运算、矩阵代数,才是符合 R 风格的代码。

如计算 \(\begin{aligned}w=\frac{1}{n} \sum_{i=1}^n|x_i-\hat{m}|\end{aligned}\),其中 \(\hat{m}\) 为中位数

# 为了表明这里是向量化的并行操作,将自变量写为大写的X
mean(abs(X - median(X)))

# 由于 R 的向量化特性,这个自定义函数天然接受向量输入
f3 <- function(X) ifelse(X >= 0, 1, 0)

多用内置函数

R base 的很多内置函数是用 C 实现的,效率很高,尽量使用。

  • sum() 向量、矩阵所有元素的和,比用循环累加快得多
  • prod() 所有元素的积
  • cumsum(),返回累计和的序列
  • cumprod(),返回累计积的序列
cumsum(1:10)
#>  [1]  1  3  6 10 15 21 28 36 45 55
cumprod(1:10)
#>  [1]       1       2       6      24     120     720    5040   40320  362880
#> [10] 3628800

避免制作副本

多用 data.table 数据框在数据上就地修改

IDE

Rstudio

R Studio cheatsheet 预览:

Shortcuts

Shortcuts
Ctrl + Shift + A 选中部分行后,格式化代码
Ctrl + Alt + I Insert chunk
Alt + - 插入 <-
Ctrl + Shift + M 插入%>%
Alt + Shift + K 显示快捷键
Ctrl + Shift + N 新建脚本 .r文件
Ctrl + Enter
Ctrl + Shift + Enter
Ctrl + Alt + R
运行一行代码
运行代码块
运行全部代码
Shift + Home/End 选中光标到行首/末之间的部分
Tab / Ctrl+Space 自动补齐
输入完函数名,按tab,自动添加开括号(和闭括号)。
Ctrl + Shift + C 注释/取消注释
F1 查看帮助
Ctrl+ ↑ 在 Console 中输入“xxx”,然后按 Ctrl+ ↑。就可以列出所有输入过的以“xxx”开头的命令。

代码高亮

GitHub 上可搜索、安装 rscodeio 主题

anthonynorth/rscodeio: An RStudio theme inspired by Visual Studio Code. (github.com)

VSCode

优点

  • 鼠标悬停,即可显示变量的定义信息和函数的帮助文档(仅限 R 包中函数的官方文档和本文件中自定义函数的定义,无法显示引入模块中的自定义函数的定义),省去了查阅文档的大量时间
  • 保存(Ctrl+S)时自动格式化
  • Ctrl+Enter自动运行一行,Ctrl+Shift+Enter自动运行当前文件

配置步骤

  1. 安装 R 包 languageserver

    install.packages("languageserver")
  2. 在 VSCode 扩展商店中安装 R 插件。

    1. 安装完成后在 VSCode 设置中搜索r.rterm.option,删除--no-save,--no-restore,添加--no-site-file和 R.exe 的路径--r-binary=C:\Program Files\R\R-4.1.3\bin\R.exe
  3. 安装 Radian:一款现代的 R console,它是用 Python 编写的

    pip install radian
    1. 安装完成后在 cmd 中输入 radian 查看是否安装成功。

    2. 若出现 “cannot determine R HOME”,可能存在多个R路径(如新安装了4.1.2版本),而 Radian 无法识别。解决这个问题的方法仍然是在 VSCode 中设置 R.exe 的路径。除了搜索r.rterm.option进行修改,也可以在设置界面的右上角打开 setting.json文件直接修改:

        "r.rterm.option": [
          "--no-site-file",
          "--r-binary=C:\\Program Files\\R\\R-4.1.3\\bin\\R.exe"
        ],
  4. VSCode 中 Radian 相关设置

    1. 搜索 r.rterm.windows,将其设置为 radian.exe 的路径。在 cmd 中(powershell 不行)输入 where radian 可以获取其路径。
    2. 搜索R: Bracketed Paste并勾选,否则 Radian 不会启用
    3. 搜索r.sessionWatcher并勾选

如何在 VSCODE 中高效使用 R 语言 (图文详解)_Baimoc-CSDN博客

---
title: "R Engineering"
subtitle: ''
author: "Humoon"
date: "`r Sys.Date()`"
output: html_document
documentclass: ctexart
classoption: hyperref,
---


```{r setup, include = FALSE}
source("../Rmarkdown-template/Rmarkdown_config.R")

## global options ===================================
knitr::opts_chunk$set(
  width = config$width,
  fig.width = config$fig.width,
  fig.asp = config$fig.asp,
  out.width = config$out.width,
  fig.align = config$fig.align,
  fig.path = config$fig.path,
  fig.show = config$fig.show,
  warn = config$warn,
  warning = config$warning,
  message = config$message,
  echo = config$echo,
  eval = config$eval,
  tidy = config$tidy,
  comment = config$comment,
  collapse = config$collapse,
  cache = config$cache,
  cache.comments = config$cache.comments,
  autodep = config$autodep
)
```

## 版本

建议安装 Microsoft R Open，对 R 中向量和矩阵的向量化操作进行了大幅优化，无需引入任何包，就能自动调用多核进行并行计算，可提高运算速度数十倍。

这也意味着，向量化运算是 R 最基本、最主要的代码风格。

但是，Microsoft R Open 的某些包更新不够及时（如 rmarkdown）。为了 Knit 的方便，可以 Rstudio 选择 R 的最新版，在 VSCode 中用 Microsoft R Open 日常加速计算。

## System interaction

### Environment

R 中词法作用域的机理通过环境实现。

函数优先在内部环境搜索用到的变量，搜索不到时，就到上一级环境搜索。

每加载一个扩展包，这个包的环境都会插入搜索路径，并位于全局环境之前。

| 环境交互函数              |                                                              |
| ------------------------- | ------------------------------------------------------------ |
| `ls()`/`objects()`        | 列出当前工作空间的所有对象                                   |
| `ls.str(mode=, pattern=)` | 显示当前环境的结构。mode 参数过滤对象类型，pattern 参数为正则表达式，过滤对象名 |
| `rm()`                    | 删除一个或更多个对象。                                       |
| `rm(list=ls(all=TRUE))`   | 删除所有对象                                                 |
| `getOption()`             | 查看全局选项                                                 |
| `options()`               | 设定全局选项。如 digits=7, 设定显示数字的位数。warn=0, 可以改为1，在警告产生时立即显示。 |

### Path

| Working  Directory  |                       |
| ------------------- | --------------------- |
| `dir.create()`      | 创建一个目录          |
| `getwd()`/`setwd()` | 查看/设定当前工作目录 |

由此扩展，R 也可以完成文件管理工作。

### Memory

`tracemem()`查看对象的内存地址

### Time

`Sys.sleep()` 使程序暂停若干秒，一般用于某些循环（爬虫、动画等），故意降低运行频率

`sys.time()` 读取系统时间；

`system.time()` 参数为大括号括起来的代码段，计算代码段运行时间

```{r, eval=FALSE}
t1 <- Sys.time()
...
t2 <- Sys.time()
print(t2 - t1) # 中间代码的运行时间

system.time({
  ...
}) # 代码段运行时间
```

```{r}
A <- matrix(1:1000000, 1000)

system.time({
  A %*% A
})
```

### Help

| Help                                  |                                |
| ------------------------------------- | ------------------------------ |
| `help(functionName)`或`?functionName` | 查看一个函数的用法             |
| `example(functionName)`               | 运行帮主文件中的例子           |
| `help.search(keyword)`或`??keyword`   | 在==所有包==的文档中搜索关键词 |
| `help(package = "")`                  | 查看一个包的帮助               |
| `help(options)`                       | 显示可用选项的说明             |
| `options()`                           | 显示或设置当前选项             |

### History

| History                 |                                                 |
| ----------------------- | ----------------------------------------------- |
| `history(#)`            | 显示最近使用过的#个命令（默认值为25）           |
| `savehistory("myfile")` | 保存命令历史到文件myfile中（默认值为.Rhistory） |
| `loadhistory("myfile")` | 载入一个命令历史文件（默认值为.Rhistory）       |



## Modularization

### R Package

| Package                        |                                                              |
| ------------------------------ | ------------------------------------------------------------ |
| `install.packages("package")`  | 安装包                                                       |
| `installed.packages()`         | 返回一个字符串矩阵，内含所有已安装的包的多项信息                 |
| `library()`                    | 无参数时，显示库中已经安装了哪些包                           |
| `library(package)`             | 有参数时，载入包                                             |
| `unloadNamespace(package)`     | 解除载入一个包                                               |
| `search()`                     | 查看环境中已经加载了哪些包                                   |
| `getOption('defaultPackages')` | 查看默认加载的 R 包                                          |
| `update.packages("package")`   | 升级包。若不填入参数，则自动升级所有可以升级的包             |
| `package::function()`          | 调用相应包的函数（有时**多个包用同一个名字命名不同的函数，会发生冲突，只能这样引用**） |
| `data()`                       | 查看所有预先提供的数据                                       |
| `data(package="")`             | 查看某个包所有预先提供的数据                                 |
| `data(dataset_name, package=)` | 读入包中数据                                                 |

```{r, eval=FALSE}
installed.packages() %>% View()
```

![](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/image-20220404055325099.png)

#### 新装 R 时安装常用包

```{r}
# 重装 R 前把已安装包的名称（第一列）存为一个 .rds 文件
saveRDS(installed.packages()[, 1], "./download-packages.rds")
```

```R
# 重装 R 后读取该文件，并安装这些 packages
install.packages(readRDS("./download-packages.rds"))
```

#### 查看包的流行程度

```{r}
# 查看 R 包的下载次数
library(cranlogs)

fashion <- function(package_name) {
  d <- cran_downloads(
    package = package_name,
    from = "2022-01-01",
    to = "2022-03-31"
  )
  sum(d$count)
}

fashion("ggplot2")
fashion("tidyverse")
fashion("data.table")
fashion("plotly")
```

### R Script

#### 语法

`source('xxx.R')` 

#### 最佳实践

由于 R 的懒加载特性，模块中的代码不会运行，故 .R 脚本文件作为模块时，不必加载配置常量和包，纯写函数即可，所有的包和配置由主文件加载。

### 二进制数据文件

数据处理的中间结果一般保存为 .rda 或 .rds 即可；有其他用途的数据转换结果，才有必要保存为 .csv 或 .json

二者区别：

1. saveRDS/readRDS 仅处理单个 R 对象。但是，它们比多对象存储方法更灵活，因为还原对象的对象名称不必与存储对象时的对象名称相同
2. .rda 不对数据进行压缩，读写速度较快；.rds 会先对文件进行压缩再保存，速度相对稍慢。

## Code Style

### 格式化

#### styler 包

[styler - A non-invasive source code formatter for R (lorenzwalthert.github.io)](https://lorenzwalthert.github.io/stylerpost/)

```R
install.packages("styler")
```

- `style_text()` styles a string
- `style_file()` styles R and Rmd files
- `style_dir()` styles all R and/or Rmd files in a directory.
- **最常用**
  - RStudio `Addins` 菜单，styles the active file R or Rmd file, or the highlighted code.
  - 或在 console 中输入`styler:::style_active_file()`
  

### Google R Style

#### 一般性规则

- 尽量避免使用`attach()`, `detach()`
- Error 应该使用`Stop()`来抛出
- S3 类和 S4 类的函数不要一起使用

#### 命名

对象命名以句号`.`分隔，不用下划线

函数名首字母大写，驼峰式命名法，不用句号分隔

#### 注释

注释行以`#`开头，后加一个空格

代码行内短注释需要在代码后面空两格，然后`#`，再加一个空格

**对变量和函数的说明写在它们的上方（紧邻），VSCode 的 R 插件能够自动识别**

#### 总体布局与顺序

1. 版权声明
2. 作者信息
3. 文件说明, 包括程序的目的，输入以及输出
4. source() 和 library() 说明
5. 函数定义
6. 可执行语句, 如果有的话 (例如, print, plot)

单元测试应在另一个独立的的文件中进行

## R 程序效率

### Vectorization

向量化运算，即对应元素执行同样的运算，适用于向量和矩阵。

如果运算符两边的变量 size 不相同，size 较小的变量会自动循环扩展，与 size 较大的变量保持一致。返回值的 size 将和较大的变量保持一致。

在计算矩阵的哈达马积、或对向量/矩阵的所有元素执行同样的变换时，向量化运算非常方便。

R 中的运算符和函数默认支持向量化运算，这是 R 的一大特色，Microsoft R Open 还对向量和矩阵的向量化运算进行了并行优化。因此，用好向量化运算、矩阵代数，才是符合 R 风格的代码。

如计算 $\begin{aligned}w=\frac{1}{n} \sum_{i=1}^n|x_i-\hat{m}|\end{aligned}$，其中 $\hat{m}$ 为中位数

```{r, eval=FALSE}
# 为了表明这里是向量化的并行操作，将自变量写为大写的X
mean(abs(X - median(X)))

# 由于 R 的向量化特性，这个自定义函数天然接受向量输入
f3 <- function(X) ifelse(X >= 0, 1, 0)
```

### 多用内置函数

R base 的很多内置函数是用 C 实现的，效率很高，尽量使用。

- sum() 向量、矩阵所有元素的和，比用循环累加快得多
- prod() 所有元素的积
- cumsum()，返回累计和的序列
- cumprod()，返回累计积的序列

```{r}
cumsum(1:10)
cumprod(1:10)
```

### 避免制作副本

多用 data.table 数据框在数据上就地修改

## IDE

### Rstudio

[R Studio cheatsheet](https://raw.githubusercontent.com/rstudio/cheatsheets/main/rstudio-ide.pdf) 预览：

<object data="../pdf/cheatsheet-rstudio-ide.pdf" type="application/pdf" width="100%" height="100%"></object>

```{r, echo=FALSE}
downloadthis::download_file(
  path = "../pdf/cheatsheet-rstudio-ide.pdf",
  output_name = "cheatsheet-rstudio-ide",
  button_label = "Download cheatsheet",
  button_type = "success",
  self_contained = FALSE
)
```

#### Shortcuts

| Shortcuts                                                  |                                                              |
| ---------------------------------------------------------- | ------------------------------------------------------------ |
| Ctrl + Shift + A                                           | 选中部分行后，格式化代码                                     |
| Ctrl + Alt + I                                             | Insert chunk                                                 |
| Alt + -                                                    | 插入 <-                                                      |
| Ctrl + Shift + M                                           | 插入%>%                                                      |
| Alt + Shift + K                                            | 显示快捷键                                                   |
| Ctrl + Shift + N                                           | 新建脚本 .r文件                                              |
| Ctrl + Enter<br />Ctrl + Shift + Enter<br />Ctrl + Alt + R | 运行一行代码<br />运行代码块<br />运行全部代码               |
| Shift + Home/End                                           | 选中光标到行首/末之间的部分                                  |
| Tab / Ctrl+Space                                           | 自动补齐<br />输入完函数名，按tab，自动添加开括号(和闭括号)。 |
| Ctrl + Shift + C                                           | 注释/取消注释                                                |
| F1                                                         | 查看帮助                                                     |
| Ctrl+ ↑                                                    | 在 Console 中输入“xxx”，然后按 Ctrl+ ↑。就可以列出所有输入过的以“xxx”开头的命令。 |

#### 代码高亮

GitHub 上可搜索、安装 rscodeio 主题

[anthonynorth/rscodeio: An RStudio theme inspired by Visual Studio Code. (github.com)](https://github.com/anthonynorth/rscodeio)

### VSCode

#### 优点

- 鼠标悬停，即可显示变量的定义信息和函数的帮助文档（仅限 R 包中函数的官方文档和本文件中自定义函数的定义，无法显示引入模块中的自定义函数的定义），省去了查阅文档的大量时间
- 保存（`Ctrl+S`）时自动格式化
- `Ctrl+Enter`自动运行一行，`Ctrl+Shift+Enter`自动运行当前文件

#### 配置步骤

1. 安装 R 包 languageserver

   ```R
   install.packages("languageserver")
   ```

2. 在 VSCode 扩展商店中安装 R 插件。

   1. 安装完成后在 VSCode 设置中搜索`r.rterm.option`，删除`--no-save,--no-restore`，添加`--no-site-file`和 R.exe 的路径`--r-binary=C:\Program Files\R\R-4.1.3\bin\R.exe`

3. 安装 Radian：一款现代的 R console，它是用 Python 编写的

   ```powershell
   pip install radian
   ```

   1. 安装完成后在 cmd 中输入 `radian` 查看是否安装成功。

   2. 若出现 “cannot determine R HOME”，可能存在多个R路径（如新安装了4.1.2版本），而 Radian 无法识别。解决这个问题的方法仍然是在 VSCode 中设置 R.exe 的路径。除了搜索`r.rterm.option`进行修改，也可以在设置界面的右上角打开 setting.json文件直接修改：

      ````json
        "r.rterm.option": [
          "--no-site-file",
          "--r-binary=C:\\Program Files\\R\\R-4.1.3\\bin\\R.exe"
        ],
      ````

4. VSCode 中 Radian 相关设置

   1. 搜索 `r.rterm.windows`，将其设置为 radian.exe 的路径。在 cmd 中（powershell 不行）输入 `where radian` 可以获取其路径。
   2. 搜索`R: Bracketed Paste`并勾选，否则 Radian 不会启用
   3. 搜索`r.sessionWatcher`并勾选



[如何在 VSCODE 中高效使用 R 语言 （图文详解）_Baimoc-CSDN博客](https://blog.csdn.net/u011262253/article/details/113837720)
